package com.company.dcm.utils;

import com.company.dcm.entity.Ota;

import java.lang.reflect.Field;
import java.util.*;

public class ObjectUtils {

    /**
     * 判断对象是否为空（根据一般常用类型区分）
     * @param object
     * @return: boolean
     */
    public static boolean isEmpty(Object object){

        //判断对象是否为null
        if (null == object){
            return true;
        }

        //判断对象是否为String类型
        if (object instanceof String){
            if (object.toString().length() == 0){
                return true;
            }
        }

        //判断对象是否为Map
        if (object instanceof Map){
            Map map = (Map)object;
            if (map.size() == 0){
                return true;
            }
        }

        //判断对象是否为List
        if (object instanceof List){
            List list = (List)object;
            if (list.size() == 0){
                return true;
            }
        }

        //普通的类对象
        Field[] fields = object.getClass().getDeclaredFields();

        //先假设全部属性都是空的，所以只要出现一个属性不为空的就不需要在循环判断
        boolean flag = true;

        for (Field field : fields) {
            field.setAccessible(true);
            try {
                if (!ObjectUtils.isEmpty(field.get(object))) {
                    flag = false;
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return flag;
    }

    /**
     * 判断obejct对象中除了names里面的字段，其他字段都为null（已知对象类型）
     * @param object
     * @param names
     * @return
     */
    public static boolean isEmpty(Object object,String... names){

        Field[] fields = object.getClass().getDeclaredFields();
        //用于判断所有属性是否为空,如果参数为空则不查询
        boolean flag = true;

        for (Field field : fields) {
            //不检查 直接取值
            field.setAccessible(true);
            try {
                String fieldName = field.getName();
                List<String> nameList = new ArrayList<>();
                if (null != names && names.length != 0){
                    nameList = Arrays.asList(names);
                }

                if (!nameList.contains(fieldName) && !Objects.isNull(field.get(object))) {
                    //不为空
                    flag = false;
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return flag;
    }

    /**
     * 判断object对象中除了names里面的字段，其他字段都为null或者是""（已知对象类型）
     * @param object
     * @param names
     * @return
     */
    public static boolean isBlank(Object object,String... names){

        Field[] fields = object.getClass().getDeclaredFields();
        //用于判断所有属性是否为空,如果参数为空则不查询
        boolean flag = true;

        for (Field field : fields) {
            //不检查 直接取值
            field.setAccessible(true);
            try {
                String fieldName = field.getName();
                List<String> nameList = new ArrayList<>();
                if (null != names && names.length != 0){
                    nameList = Arrays.asList(names);
                }
                Object value = field.get(object);
                if (!nameList.contains(fieldName) && !isEmpty(value)) {
                    //不为空
                    flag = false;
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return flag;
    }

    /**
     * 查找列表中版本号最大的对象
     * @param Otas 对象列表
     * @return 具有最大版本号的对象，如果列表为空返回 null
     */
    public static Ota findMaxVersionObject(List<Ota> Otas) {
        if (Otas == null || Otas.isEmpty()) return null;

        Ota maxObject = Otas.get(0);
        String currentMaxVersion = null;

        for (Ota ota : Otas) {
            // 比较对象的两个版本号，取较大者
            String objMaxVersion = compareVersions(ota.getSoftwareVersion(), maxObject.getSoftwareVersion()) > 0
                    ? ota.getSoftwareVersion()
                    : maxObject.getSoftwareVersion();

            // 更新最大值
            if (currentMaxVersion == null ||
                    compareVersions(objMaxVersion, currentMaxVersion) > 0) {
                currentMaxVersion = objMaxVersion;
                maxObject = ota;
            }
        }

        return maxObject;
    }

    /**
     * 比较两个版本号（x.x.x 格式）
     * @return 1: v1 > v2, -1: v1 < v2, 0: 相等
     */
    private static int compareVersions(String v1, String v2) {
        String[] parts1 = v1.split("\\.");
        String[] parts2 = v2.split("\\.");

        int maxLength = Math.max(parts1.length, parts2.length);
        for (int i = 0; i < maxLength; i++) {
            // 将每段转换为整数，缺失部分默认为0
            int num1 = (i < parts1.length) ? Integer.parseInt(parts1[i]) : 0;
            int num2 = (i < parts2.length) ? Integer.parseInt(parts2[i]) : 0;

            if (num1 > num2) return 1;
            else if (num1 < num2) return -1;
        }
        return 0; // 所有部分相等
    }


}

